const Router = require("koa-router");
const router = new Router();
const KoaConfig = require("../../../koaconfig");
const multer = require("@koa/multer");
const fs = require("fs");
const path = require("path");
const { verifyToken } = require("../../utils/tokenTool");
const {
  addArticleLike,
  deleteArticleById,
  cancelArticleLike,
  addArticle,
  modifyArticle,
  getArticleDetail,
  getAuthorToModifyArticle,
} = require("../../db/DBApi/ArticleApi");
const { isAuthorExist } = require("../../db/DBApi/DBcommentApi");
const {
  addDraft,
  getDraftInfo,
  saveDraft,
  deleteDraft,
  saveDraftToArticle,
  getDraftList,
} = require("../../db/DBApi/DraftApi");

router.prefix(KoaConfig.path.private);

// 点赞
router.get("/likes", verifyToken, async (ctx, next) => {
  // 前端传回文章的id和作者email
  const articleId = ctx.request.query.articleId;
  const email = ctx.state.user.email;

  // 更新文章的点赞数
  const result = await addArticleLike(email, articleId);

  // 点赞是否成功
  if (!result) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "点赞失败",
    };
    return;
  }

  // 返回点赞结果
  ctx.status = 200;
  ctx.body = {
    code: 200,
    data: "点赞成功",
  };
});

// 取消点赞
router.get("/cancelLikes", verifyToken, async (ctx, next) => {
  // 前端传回文章的id和作者email
  const articleId = ctx.request.query.articleId;
  const email = ctx.state.user.email;

  // 更新文章的点赞数
  const result = await cancelArticleLike(email, articleId);

  // 取消点赞是否成功
  if (!result) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "取消点赞失败作者未点赞文章",
    };
    return;
  }

  // 返回取消点赞结果
  ctx.status = 200;
  ctx.body = {
    code: 200,
    data: "取消点赞成功",
  };
});

/*

// 添加文章
// 添加文章部分有可能需要上传图片，后期的添加图片的时候会考虑到
// router.post("/addArticle", verifyToken, async (ctx, next) => {
//   // 前端传回文章信息
//   const { title, content, authorId, summary } = ctx.request.body;

//   // 调用数据库API添加文章
//   const result = await addArticle(authorId, title, content, summary);

//   // 添加文章是否成功
//   if (!result) {
//     ctx.body = {
//       code: 500,
//       data: "添加文章失败",
//     };
//     return;
//   }

//   // 返回添加文章结果
//   ctx.body = {
//     code: 200,
//     data: "添加文章成功",
//   };
// });

*/

// 添加草稿，相当于是创建草稿，必须要先添加草稿，然后才能发布文章
// 发现问题：
// 1. 草稿的数量没有限制
// 2. 草稿是否已经存在作者的草稿列表中没有进行验证
// 后期可以通过限制草稿的数量来限制用户的草稿的数量
router.get("/addDraft", verifyToken, async (ctx, next) => {
  // 获取前端的用户信息
  const email = ctx.state.user.email;

  // 添加草稿
  const result = await addDraft(email, {
    title: "",
    summary: "",
    content: "",
    createTime: new Date(),
  });

  // 添加草稿是否成功
  if (!result) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "添加草稿失败",
    };
    return;
  }

  // 创建作者草稿目录
  const draftDir = path.join(
    __dirname,
    "../../../public/author",
    email,
    "articles",
    result._id.toString()
  );
  fs.mkdirSync(draftDir, { recursive: true });

  // 返回添加草稿结果
  ctx.status = 200;
  ctx.body = {
    code: 200,
    msg: "添加草稿成功",
    data: {
      draftId: result._id,
    },
  };
});

// 保存草稿，修改草稿
router.post("/saveDraft", verifyToken, async (ctx, next) => {
  // 获取前端的用户信息
  const email = ctx.state.user.email;
  const { draftId, title, summary, content, createTime } = ctx.request.body;

  // 前端传回草稿信息
  const saveDraftResult = await saveDraft(email, draftId, {
    title: title,
    summary: summary,
    content: content,
    createTime: createTime || new Date(),
  });

  // 保存草稿是否成功
  if (!saveDraftResult) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "保存草稿失败",
    };
    return;
  }

  console.log("saveDraftResult", saveDraftResult);

  // 返回保存草稿结果
  ctx.status = 200;
  ctx.body = {
    code: 200,
    data: "保存草稿成功",
  };
});

// 将草稿保存为文章或者发布文章
// 将草稿保存为文章之前必须先添加草稿，然后将草稿保存为文章
router.post("/publishArticle", verifyToken, async (ctx, next) => {
  // 获取前端的用户信息
  const email = ctx.state.user.email;
  const { articleId, title, summary, content, createTime, draftId } =
    ctx.request.body;

  console.log(
    "publishArticle",
    articleId,
    title,
    summary,
    content,
    createTime,
    draftId
  );

  // 判断用户是否存在
  const author = await isAuthorExist(email);

  // 判断作者是否存在
  if (!author) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "作者不存在",
    };
    return;
  }

  // 判断文章是否是作者的文章或者是作者的草稿，或者是其他作者的文章或草稿
  if (author.articles.includes(articleId)) {
    // 说明文章需要更新
    const result = await modifyArticle(articleId, email, {
      title: title,
      summary: summary,
      content: content,
    });

    // 修改文章是否成功
    if (!result) {
      ctx.status = 500;
      ctx.body = {
        code: 500,
        data: "更新文章失败",
      };
      return;
    }

    // 返回发布文章结果
    ctx.status = 200;
    ctx.body = {
      code: 200,
      data: "更新文章成功",
    };
  } else if (author.drafts.includes(draftId)) {
    console.log("草稿保存为文章", draftId);
    // 说明草稿需要保存为文章
    // 将草稿保存为文章时一定需要将草稿的id变成对应文章的id
    // 否则会导致文章的图片丢失
    const result = await saveDraftToArticle(email, draftId, {
      title: title,
      summary: summary,
      content: content,
      createTime: createTime || new Date(),
    });

    console.log("草稿保存为文章结果", result);

    // 保存草稿为文章是否成功
    if (!result) {
      ctx.status = 500;
      ctx.body = {
        code: 500,
        data: "文章发布失败",
      };
      return;
    }

    // 获取文章id
    const articleId = result._id;

    // 将对应文章的目录名进行修改名字
    // 将草稿名换成文章名
    const draftDir = path.join(
      __dirname,
      "../../../public/author",
      email,
      "articles",
      draftId
    );
    const articleDir = path.join(
      __dirname,
      "../../../public/author",
      email,
      "articles",
      articleId.toString()
    );

    // 将草稿Id重命名为文章Id
    fs.rename(draftDir, articleDir, (err) => {
      if (err) {
        console.log("重命名失败", err);
        return;
      } else {
        console.log("重命名成功");
      }
    });

    // 将文章中的图片路径进行修改
    const newContent = content.replace(new RegExp(draftId, "g"), articleId);

    // 更新文章内容
    const modifyResult = await modifyArticle(articleId, email, {
      title: title,
      summary: summary,
      content: newContent,
    });

    // 修改文章是否成功
    if (!modifyResult) {
      ctx.status = 500;
      ctx.body = {
        code: 500,
        data: "文章发布失败",
      };
      return;
    }

    // 返回发布文章结果
    ctx.status = 200;
    ctx.body = {
      code: 200,
      data: {
        articleId: result._id,
      },
    };
  } else {
    // 说明不是作者的文章或草稿
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "文章或者草稿不存在或者不属于作者",
    };
  }
});

// 获取草稿详细信息
router.post("/getDraft", verifyToken, async (ctx, next) => {
  // 获取前端的用户信息
  const email = ctx.state.user.email;
  const { draftId } = ctx.request.body;

  // 获取草稿信息
  const result = await getDraftInfo(email, draftId);

  // 获取草稿是否成功
  if (!result) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "获取草稿失败",
    };
    return;
  }

  // 返回获取草稿结果
  ctx.status = 200;
  ctx.body = {
    code: 200,
    data: result,
  };
});

// 作者获取草稿列表
router.get("/getDraftList", verifyToken, async (ctx, next) => {
  // 前端传递的参数
  const email = ctx.state.user.email;

  // 调用数据库API，获取草稿列表
  const res = await getDraftList(email);

  // 获取草稿列表失败
  if (!res) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      message: "获取草稿列表失败",
    };
    return;
  }

  // 获取草稿列表成功
  ctx.status = 200;
  ctx.body = {
    code: 200,
    data: res,
  };
});

// 删除草稿
router.get("/deleteDraft", verifyToken, async (ctx, next) => {
  // 获取前端的用户信息
  const email = ctx.state.user.email;
  const { draftId } = ctx.request.query;

  // 调用数据库API删除草稿
  const result = await deleteDraft(email, draftId);

  // 删除草稿是否成功
  if (!result) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "删除草稿失败",
    };
    return;
  }

  // 删除草稿的图片
  const draftDir = path.join(
    __dirname,
    "../../../public/author",
    email,
    "articles",
    draftId
  );
  fs.rmSync(draftDir, { recursive: true });

  // 返回删除草稿结果
  ctx.status = 200;
  ctx.body = {
    code: 200,
    data: "删除草稿成功",
  };
});

// 获取要修改的文章
router.get("/getAuthorChangeArticle", verifyToken, async (ctx, next) => {
  // 前端传回文章id
  const email = ctx.state.user.email;
  const { articleId } = ctx.request.query;

  // 获取文章信息
  const result = await getAuthorToModifyArticle(email, articleId);

  // 获取文章是否成功
  if (!result) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "获取文章失败",
    };
    return;
  }

  // 返回获取文章结果
  ctx.status = 200;
  ctx.body = {
    code: 200,
    data: result,
  };
});

/*
// 修改文章
// 修改文章部分有可能需要修改，后期的添加图片的时候会考虑到
// router.post("/modifyArticle", verifyToken, async (ctx, next) => {
//   // 前端传回文章信息
//   const { articleId, newTitle, newContent, newSummary } = ctx.request.body;

//   // 调用数据库API修改文章
//   const result = await modifyArticle(
//     articleId,
//     newTitle,
//     newContent,
//     newSummary
//   );

//   // 修改文章是否成功
//   if (!result) {
//     ctx.body = {
//       code: 500,
//       data: "修改文章失败",
//     };
//     return;
//   }

//   // 返回修改文章结果
//   ctx.body = {
//     code: 200,
//     data: "修改文章成功",
//   };
// });
*/

// 删除文章
// 删除文章之后图片可能需要删除，后期的添加图片的时候会考虑到
router.post("/deleteArticle", verifyToken, async (ctx, next) => {
  // 前端传回文章id和作者email
  const email = ctx.state.user.email;
  const { articleId } = ctx.request.body;

  // 调用数据库API删除文章
  const result = await deleteArticleById(articleId, email);

  // 删除文章是否成功
  if (!result) {
    ctx.status = 500;
    ctx.body = {
      code: 500,
      data: "删除文章失败",
    };
    return;
  }

  // 删除文章的图片
  const articleDir = path.join(
    __dirname,
    "../../../public/author",
    email,
    "articles",
    articleId.toString()
  );
  fs.rmSync(articleDir, { recursive: true });

  // 返回删除文章结果
  ctx.status = 200;
  ctx.body = {
    code: 200,
    data: "删除文章成功",
  };
});

// 上传文件存放路径、及文件命名
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    // 这里说明req.user.email是可以用的
    const email = req.user.email;

    const articleId = req.body.articleId;

    const articleDir = path.join(
      __dirname,
      "../../../public/author",
      email,
      "articles",
      articleId?.toString()
    );
    console.log("path at storage", articleDir);
    cb(null, articleDir);
  },
  filename: function (req, file, cb) {
    cb(null, `${Date.now()}-${file.originalname}`); // 文件名加上时间戳
  },
});
//文件上传限制
const limits = {
  fields: 10, //非文件字段的数量
  fileSize: 10 * 1024 * 1024, //文件大小 单位 10MB
  files: 1, //文件数量
};
const upload = multer({ storage, limits });

// 用户上传文章的图片
router.post(
  "/uplaodArticleImg",
  verifyToken,
  upload.single("file"),
  async (ctx, next) => {
    // 在这里就没有做过多的判断了，比如判断文件是否上传成功
    // 获取作者的email
    const email = ctx.state.user.email;
    // 获取文章id
    const { articleId } = ctx.request.body;

    // 获取上传的文件
    const file = ctx.file;

    // 响应
    ctx.status = 200;
    ctx.body = {
      code: 200,
      data: {
        url: `http://${KoaConfig.host}:3000/author/${email}/articles/${articleId}/${file.filename}`,
        alt: "图片描述文字",
        href: "图片的链接",
      },
    };
  }
);

module.exports = router;
